home *** CD-ROM | disk | FTP | other *** search
/ Workbench Design / WB Collection.iso / workbench werkzeuge / commoditys / cx13 / txt / cx.mod < prev    next >
Text File  |  1996-04-07  |  39KB  |  1,175 lines
  1. MODULE CX;
  2.  
  3.    (* CX.mod - Ersatz für das "Exchange"-Programm der Workbench
  4.     * Version     : $VER: CX.mod 1.2 (© 1994 Fin Schuppenhauer)
  5.     * Autor       : Fin Schuppenhauer
  6.     *               Braußpark 10
  7.     *               20537 Hamburg
  8.     *               (Germany)
  9.     * E-Mail      : schuppenhauer@informatik.uni-hamburg.de
  10.     * Erstellt am : 31 Aug 1994
  11.     * Letzte Änd. : 18 Sep 1994
  12.     *)
  13.  
  14.    (*$ DEFINE Debug:=FALSE *)
  15.  
  16. IMPORT cd:CommoditiesD,          cl:CommoditiesL,   cp:CommoditiesPrivate,
  17.        cs:CommoditiesSupport,
  18.        ed:ExecD,                 el:ExecL,          es:ExecSupport,
  19.        id:IntuitionD,            il:IntuitionL,     im:IntuiMacros,
  20.        gtd:GadToolsD,            gtl:GadToolsL,
  21.        gd:GraphicsD,             gl:GraphicsL,
  22.        dd:DosD,                  dl:DosL,
  23.        ld:LocaleD,               ll:LocaleL,
  24.        iv:InputEvent,
  25.        ASCII,
  26.        lan:ListsAndNodes,
  27.        cxc:CXCatalog,
  28.    (*$ IF Debug *)
  29.        Arts,
  30.        t:Terminal,
  31.    (*$ ENDIF *)
  32.        str:String;
  33.  
  34. FROM SYSTEM IMPORT LONGSET, CAST, ADR, ADDRESS, TAG, BITSET;
  35. FROM UtilityD IMPORT tagEnd;
  36. (*$ IF Debug *)
  37. FROM InOut IMPORT WriteCard;
  38. (*$ ENDIF *)
  39.  
  40. CONST
  41.    (* Konstanten für die Gadgets: *)
  42.    LISTGADGET        = 0; (* Die ID-Nummern der ersten drei Gadgets *)
  43.    SHOWGADGET        = 1; (* dürfen nicht verändert werden! (siehe  *)
  44.    HIDEGADGET        = 2; (* ProcessMsg())                          *)
  45.    ENABLEGADGET      = 3;
  46.    KILLGADGET        = 4;
  47.    DISABLEALLGADGET  = 5; (* Diese zwei ID-Nummern dürfen ebenfalls *)
  48.    KILLALLGADGET     = 6; (* nicht verändert werden!                *)
  49.    GADGETCOUNT       = 7;
  50.  
  51.    (* Koordinaten der Bevelbox: *)
  52.    BEVELTOP    = 25;
  53.    BEVELLEFT   = 209;
  54.    BEVELWIDTH  = 340;
  55.    BEVELHEIGHT = 28;
  56.  
  57.    IVHOTKEY = 1;
  58.  
  59.    (* Menü: *)
  60.    PROJEKT  = 0;
  61.       ABOUTMENU      = 0;
  62.       (* ~~~~~~~~~~~ = 1 *)
  63.       HIDEMENU       = 2;
  64.       QUITMENU       = 3;
  65.    EDIT     = 1;
  66.       DISABLEALLMENU = 0;
  67.       ENABLEALLMENU  = 1;
  68.       KILLALLMENU    = 2;
  69.       (* nmEnd *)
  70.  
  71.    MENUCOUNT = 10;
  72.  
  73. CONST
  74.    YSTEP    = 2;
  75.    XSTEP    = 4;
  76.  
  77. TYPE
  78.    StrPtr = POINTER TO ARRAY [0..127] OF CHAR;
  79.  
  80.    UpperLowerCase = (lower, upper);
  81.  
  82.    MyTime = RECORD
  83.       seconds, micros : LONGCARD;
  84.    END;
  85.  
  86. VAR
  87.    brokerport  : ed.MsgPortPtr;  (* über diesen Port läuft die gesamte Kommunikation *)
  88.    nb          : cd.NewBroker;
  89.    broker      : cd.CxObjPtr;
  90.    error       : LONGCARD;       (* für Errorcode von CxBroker() *)
  91.    cxsigflag   : SHORTCARD;      (* Signal bei eintreffenden Broker- oder Intuition-Msgs. *)
  92.    bool        : BOOLEAN;        (* dummy *)
  93.    msg         : ed.MessagePtr;
  94.    defhotkey   : ARRAY [0..127] OF CHAR;
  95.    hotkey      : StrPtr;
  96.    hotkeyfilter: cd.CxObjPtr;
  97.    dummystr    : StrPtr;
  98.  
  99. VAR
  100.    window      : id.WindowPtr;
  101.    wintitle    : ARRAY [0..127] OF CHAR;
  102.    winreplyport: ed.MsgPortPtr;
  103.    vi          : ADDRESS;
  104.    glist       : id.GadgetPtr;
  105.    gadget      : ARRAY [0..GADGETCOUNT-1] OF id.GadgetPtr;
  106.    CycleLabels : POINTER TO ARRAY [0..2] OF ADDRESS;
  107.    allCycleLabels: POINTER TO ARRAY [0..2] OF ADDRESS;
  108.    menuStrip   : id.MenuPtr;
  109.    topazfont   : gd.TextFontPtr;
  110.    topaz8      : gd.TextAttr;
  111.    bevelWidth,
  112.    bevelHeight : INTEGER;
  113.  
  114.    brokerlist  : ed.ListPtr;    (* Liste der Broker; wird gleichzeitig für das LV-Gadget genutzt *)
  115.  
  116.    catalog     : ld.CatalogPtr;
  117.  
  118.    requester   : BOOLEAN;
  119.  
  120.  
  121.  
  122. PROCEDURE CreateCommoditiesList (VAR blist : ed.ListPtr);
  123. (** "Liste für Listview-Gadget erzeugen"
  124. *)
  125. VAR
  126.    li                : LONGINT;
  127. BEGIN
  128.    blist := el.AllocMem(SIZE(ed.List), ed.MemReqSet{ed.public});
  129.    IF blist # NIL THEN
  130.       es.NewList (blist);
  131.  
  132.       (* Kopie der System-Broker-List anlegen: *)
  133.       li := cp.CopyBrokerList (blist);
  134.    END;
  135.    lan.SortExecList (blist, INTEGER(lan.CountNodes(blist)));
  136. END CreateCommoditiesList;
  137. (* **)
  138.  
  139. PROCEDURE FreeCommoditiesList (VAR blist : ed.ListPtr);
  140. (** "Gibt den durch CreateCommoditiesList() belegeten speicher frei" *)
  141. VAR
  142.    li : LONGINT;
  143. BEGIN
  144.    IF blist # NIL THEN
  145.       li := cp.FreeBrokerList(blist);
  146.       el.FreeMem (blist, SIZE(ed.List));
  147.       blist := NIL;
  148.    END;
  149. END FreeCommoditiesList;
  150. (* **)
  151.  
  152. PROCEDURE UpdateCommoditiesList (VAR blist : ed.ListPtr);
  153. (** "Erneuert die LV-Gadget-Liste" *)
  154. VAR
  155.    dummylistptr: ADDRESS;
  156.    li          : LONGINT;
  157.    taglist     : ARRAY [0..7] OF LONGINT;
  158. BEGIN
  159.    FreeCommoditiesList (blist);
  160.    CreateCommoditiesList (blist);
  161.  
  162.    dummylistptr := blist;
  163.    gtl.GTSetGadgetAttrsA (gadget[LISTGADGET], window, NIL, TAG(taglist,
  164.       gtd.gtlvLabels,   dummylistptr,
  165.       tagEnd));
  166. END UpdateCommoditiesList;
  167. (* **)
  168.  
  169. PROCEDURE CountBrokers (blist : ed.ListPtr) : CARDINAL;
  170. (** "Berechnet die Anzahl der angezeigten Broker" *)
  171. VAR
  172.    node  : ed.NodePtr;
  173.    count : CARDINAL;
  174. BEGIN
  175.    RETURN CARDINAL(lan.CountNodes (blist)) - 1;
  176.    (* Bemerkung:
  177.     * In der Brokerliste gibt es einen besonderen Broker, der
  178.     * die Liste abschließt (CxObj-Type = cxZero). Den wollen
  179.     * wir natürlich nicht mitzählen.
  180.     *)
  181. END CountBrokers;
  182. (* **)
  183.  
  184.  
  185.  
  186. PROCEDURE ShowWindow;
  187. (** "Fenster öffnen, Gadgets zeichnen u.s.w." *)
  188. VAR
  189.    screen      : id.ScreenPtr;
  190.    taglist     : ARRAY [0..29] OF LONGINT;
  191.    gad         : id.GadgetPtr;
  192.    ng          : gtd.NewGadget;
  193.    rp          : gd.RastPortPtr;
  194.    mynewmenu   : POINTER TO ARRAY [0..MENUCOUNT-1] OF gtd.NewMenu;
  195.    font        : gd.TextAttrPtr;
  196.    buttonHeight: INTEGER;
  197.    buttonWidth : INTEGER;
  198.    listviewTop : INTEGER;
  199.    buttonTop   : INTEGER;
  200.    infostr     : StrPtr;
  201.    dummy       : INTEGER;
  202.    innerHeight : INTEGER;
  203.  
  204.    PROCEDURE ComputeWidths(VAR bevelwidth, buttonwidth : INTEGER);
  205. (** "Berechnet den Platz des längsten Buttons": *)
  206.    VAR
  207.       userfont : gd.TextFontPtr;
  208.    BEGIN
  209.       userfont := gl.OpenFont(screen^.font);
  210.       bevelwidth := userfont^.xSize * 44;
  211.       buttonwidth := (bevelwidth - XSTEP) DIV 2;
  212.       gl.CloseFont(userfont);
  213.    END ComputeWidths;
  214. (* **)
  215.  
  216.    PROCEDURE SetShortcutAndLabel (VAR nm : gtd.NewMenu;
  217.                                   localMsg : ADDRESS);
  218. (** "Für Menü Shortcut und Labeltext setzen" *)
  219.    BEGIN
  220.       WITH nm DO
  221.          commKey  := localMsg;
  222.          label    := localMsg + CAST(ADDRESS, 2);
  223.          IF CAST(StrPtr, localMsg)^[0] = " " THEN
  224.             commKey := NIL;
  225.          END;
  226.       END;
  227.    END SetShortcutAndLabel;
  228. (* **)
  229.  
  230. BEGIN
  231.    IF window # NIL THEN
  232.       (* Das Fenster ist bereist geöffnet! *)
  233.       RETURN;
  234.    END;
  235.  
  236.    (* Fenster soll auf dem Default(Workbench)-Screen erscheinen: *)
  237.    screen := il.LockPubScreen (NIL);
  238.    IF screen = NIL THEN
  239.       RETURN;
  240.    END;
  241.  
  242.    vi := gtl.GetVisualInfoA(screen, TAG(taglist, tagEnd));
  243.    IF vi = NIL THEN
  244.       il.UnlockPubScreen (NIL, screen);
  245.       RETURN;
  246.    END;
  247.  
  248. (** Menü-Stuff: *)
  249.    mynewmenu := el.AllocMem(MENUCOUNT*SIZE(gtd.NewMenu), ed.MemReqSet{ed.public,ed.memClear});
  250.    IF mynewmenu # NIL THEN
  251.       WITH mynewmenu^[0] DO
  252.          type        := gtd.nmTitle;
  253.          label       := ll.GetCatalogStr(catalog, cxc.MSG_PROJECT_MENU, ADR(cxc.MSG_PROJECT_MENUSTR));
  254.          menuFlags   := BITSET{};
  255.       END;
  256.       WITH mynewmenu^[1] DO
  257.          type        := gtd.nmItem;
  258.          SetShortcutAndLabel (mynewmenu^[1], ll.GetCatalogStr(catalog, cxc.MSG_PROJECT_ABOUT, ADR(cxc.MSG_PROJECT_ABOUTSTR)));
  259. (*         label       := ll.GetCatalogStr(catalog, cxc.MSG_PROJECT_ABOUT, ADR(cxc.MSG_PROJECT_ABOUTSTR));
  260.          commKey     := ADR("?");*)
  261.       END;
  262.       WITH mynewmenu^[2] DO
  263.          type        := gtd.nmItem;
  264.          label       := gtd.nmBarlabel;
  265.       END;
  266.       WITH mynewmenu^[3] DO
  267.          type        := gtd.nmItem;
  268.          SetShortcutAndLabel (mynewmenu^[3], ll.GetCatalogStr(catalog, cxc.MSG_PROJECT_HIDE, ADR(cxc.MSG_PROJECT_HIDESTR)));
  269. (*         label       := ll.GetCatalogStr(catalog, cxc.MSG_PROJECT_HIDE, ADR(cxc.MSG_PROJECT_HIDESTR));
  270.          commKey     := ADR("H");*)
  271.       END;
  272.       WITH mynewmenu^[4] DO
  273.          type        := gtd.nmItem;
  274.          SetShortcutAndLabel (mynewmenu^[4], ll.GetCatalogStr(catalog, cxc.MSG_PROJECT_QUIT, ADR(cxc.MSG_PROJECT_QUITSTR)));
  275. (*         label       := ll.GetCatalogStr(catalog, cxc.MSG_PROJECT_QUIT, ADR(cxc.MSG_PROJECT_QUITSTR));
  276.          commKey     := ADR("Q");*)
  277.       END;
  278.  
  279.       WITH mynewmenu^[5] DO
  280.          type        := gtd.nmTitle;
  281.          label       := ll.GetCatalogStr(catalog, cxc.MSG_CONTROL_MENU, ADR(cxc.MSG_CONTROL_MENUSTR));
  282.          menuFlags   := BITSET{};
  283.       END;
  284.       WITH mynewmenu^[6] DO
  285.          type        := gtd.nmItem;
  286.          SetShortcutAndLabel (mynewmenu^[6], ll.GetCatalogStr(catalog, cxc.MSG_CONTROL_DISABLEALL, ADR(cxc.MSG_CONTROL_DISABLEALLSTR)));
  287. (*         label       := ll.GetCatalogStr(catalog, cxc.MSG_CONTROL_DISABLEALL, ADR(cxc.MSG_CONTROL_DISABLEALLSTR));
  288.          commKey     := ADR("D");*)
  289.       END;
  290.       WITH mynewmenu^[7] DO
  291.          type        := gtd.nmItem;
  292.          SetShortcutAndLabel (mynewmenu^[7], ll.GetCatalogStr(catalog, cxc.MSG_CONTROL_ENABLEALL, ADR(cxc.MSG_CONTROL_ENABLEALLSTR)));
  293. (*         label       := ll.GetCatalogStr(catalog, cxc.MSG_CONTROL_ENABLEALL, ADR(cxc.MSG_CONTROL_ENABLEALLSTR));
  294.          commKey     := ADR("E");*)
  295.       END;
  296.       WITH mynewmenu^[8] DO
  297.          type        := gtd.nmItem;
  298.          SetShortcutAndLabel (mynewmenu^[8], ll.GetCatalogStr(catalog, cxc.MSG_CONTROL_KILLALL, ADR(cxc.MSG_CONTROL_KILLALLSTR)));
  299. (*         label       := ll.GetCatalogStr(catalog, cxc.MSG_CONTROL_KILLALL, ADR(cxc.MSG_CONTROL_KILLALLSTR));
  300.          commKey     := ADR("K");*)
  301.       END;
  302.       WITH mynewmenu^[9] DO
  303.          type        := gtd.nmEnd;
  304.       END;
  305.    ELSE
  306.       gtl.FreeVisualInfo (vi);
  307.       il.UnlockPubScreen (NIL, screen);
  308.       RETURN;
  309.    END;
  310. (* **)
  311.  
  312.    glist := NIL;
  313.    gad := gtl.CreateContext(glist);
  314.  
  315.    (* Stuff für die Font-Sensitivität: *)
  316.    font := screen^.font;
  317.    buttonHeight := font^.ySize + 4;
  318.    ComputeWidths (bevelWidth, buttonWidth);
  319.    bevelHeight := 2 * font^.ySize + 3*YSTEP + 4;   (* +4 läßt das bei Topaz8 gut aussehen *)
  320.    listviewTop := 2 * font^.ySize;
  321.    buttonTop := listviewTop + bevelHeight + YSTEP;
  322.  
  323.    (* Gadgets definieren: *)
  324.    (* Listview-Gadget: *)
  325.    WITH ng DO
  326.       leftEdge := 5;
  327.       topEdge  := listviewTop;
  328.       width    := 200;
  329.       height   := bevelHeight + 3*(2+YSTEP+buttonHeight);   (* 2+ weil buttonHeight nur die innere Höhe zu sein scheint *)
  330.       gadgetText:= ll.GetCatalogStr(catalog, cxc.MSG_AVAILABLECOMMODITIES_GAD, ADR(cxc.MSG_AVAILABLECOMMODITIES_GADSTR));
  331.       textAttr := font;
  332.       gadgetID := LISTGADGET;
  333.       flags    := gtd.NewGadgetFlagSet{gtd.placetextAbove};
  334.       visualInfo:= vi;
  335.       userData := NIL;
  336.    END;
  337.    CreateCommoditiesList (brokerlist);
  338.    gad := gtl.CreateGadgetA(gtd.listviewKind, gad^, ng, TAG(taglist,
  339.       gtd.gtlvLabels,         brokerlist,
  340.       gtd.gtlvShowSelected,   NIL,
  341.       gtd.gtlvSelected,       0,
  342.       gtd.gtUnderscore,       "_",
  343.       tagEnd));
  344.    gadget[LISTGADGET] := gad;
  345.  
  346.    (* "Anzeige sichtbar"-Gadget: *)
  347.    WITH ng DO
  348.       leftEdge := 209;
  349.       topEdge  := buttonTop;
  350.       width    := buttonWidth;
  351.       height   := buttonHeight;
  352.       gadgetText:= ll.GetCatalogStr(catalog, cxc.MSG_SHOWINTERFACE_GAD, ADR(cxc.MSG_SHOWINTERFACE_GADSTR));
  353.       gadgetID := SHOWGADGET;
  354.       flags    := gtd.NewGadgetFlagSet{gtd.placetextIn};
  355.    END;
  356.    gad := gtl.CreateGadgetA(gtd.buttonKind, gad^, ng, TAG(taglist,
  357.       id.gaDisabled,    FALSE,
  358.       gtd.gtUnderscore, "_",
  359.       tagEnd));
  360.    gadget[SHOWGADGET] := gad;
  361.  
  362.    (* In-/Aktive-Cycle-Gadget: *)
  363.    CycleLabels := el.AllocMem(3*SIZE(ADDRESS), ed.MemReqSet{ed.public,ed.memClear});
  364.    IF CycleLabels # NIL THEN
  365.       CycleLabels^[0] := ll.GetCatalogStr(catalog, cxc.MSG_ACTIVE, ADR(cxc.MSG_ACTIVESTR));
  366.       CycleLabels^[1] := ll.GetCatalogStr(catalog, cxc.MSG_INACTIVE, ADR(cxc.MSG_INACTIVESTR));
  367.       CycleLabels^[2] := NIL;
  368.       WITH ng DO
  369.          topEdge  := topEdge + buttonHeight + YSTEP;
  370.          gadgetText:= NIL;
  371.          gadgetID := ENABLEGADGET;
  372.       END;
  373.       gad := gtl.CreateGadgetA(gtd.cycleKind, gad^, ng, TAG(taglist,
  374.          id.gaDisabled,    FALSE,
  375.          gtd.gtcyLabels,   CycleLabels,
  376.          tagEnd));
  377.       gadget[ENABLEGADGET] := gad;
  378.    END;
  379.  
  380.    (* "Alle deaktivieren"-Gadget: *)
  381.    allCycleLabels := el.AllocMem(3*SIZE(ADDRESS), ed.MemReqSet{ed.memClear});
  382.    IF allCycleLabels # NIL THEN
  383.       allCycleLabels^[0] := ll.GetCatalogStr(catalog, cxc.MSG_DISABLEALL, ADR(cxc.MSG_DISABLEALLSTR));
  384.       allCycleLabels^[1] := ll.GetCatalogStr(catalog, cxc.MSG_ENABLEALL,  ADR(cxc.MSG_ENABLEALLSTR));
  385.       WITH ng DO
  386.          topEdge  := topEdge + buttonHeight + YSTEP;
  387.          gadgetText := NIL;
  388.          gadgetID := DISABLEALLGADGET;
  389.       END;
  390.       gad := gtl.CreateGadgetA(gtd.cycleKind, gad^, ng, TAG(taglist,
  391.          gtd.gtUnderscore,    "_",
  392.          gtd.gtcyLabels,      allCycleLabels,
  393.          tagEnd));
  394.       gadget[DISABLEALLGADGET] := gad;
  395.    END;
  396.  
  397.    (* "Anzeige verbergen"-Gadget: *)
  398.    WITH ng DO
  399.       leftEdge := leftEdge + buttonWidth + XSTEP;
  400.       topEdge  := buttonTop;
  401.       gadgetText := ll.GetCatalogStr(catalog, cxc.MSG_HIDEINTERFACE_GAD, ADR(cxc.MSG_HIDEINTERFACE_GADSTR));
  402.       gadgetID := HIDEGADGET;
  403.    END;
  404.    gad := gtl.CreateGadgetA(gtd.buttonKind, gad^, ng, TAG(taglist,
  405.       id.gaDisabled,       FALSE,
  406.       gtd.gtUnderscore,    "_",
  407.       tagEnd));
  408.    gadget[HIDEGADGET] := gad;
  409.  
  410.    (* "Entfernen"-Gadget: *)
  411.    WITH ng DO
  412.       topEdge  := topEdge + buttonHeight + YSTEP;
  413.       gadgetText := ll.GetCatalogStr(catalog, cxc.MSG_REMOVE_GAD, ADR(cxc.MSG_REMOVE_GADSTR));
  414.       gadgetID := KILLGADGET;
  415.    END;
  416.    gad := gtl.CreateGadgetA(gtd.buttonKind, gad^, ng, TAG(taglist,
  417.       id.gaDisabled,       FALSE,
  418.       gtd.gtUnderscore,    "_",
  419.       tagEnd));
  420.    gadget[KILLGADGET] := gad;
  421.  
  422.    (* "Alle entfernen"-Button: *)
  423.    WITH ng DO
  424.       topEdge  := topEdge + buttonHeight + YSTEP;
  425.       gadgetText := ll.GetCatalogStr(catalog, cxc.MSG_REMOVEALL_GAD, ADR(cxc.MSG_REMOVEALL_GADSTR));
  426.       gadgetID := KILLALLGADGET;
  427.    END;
  428.    gad := gtl.CreateGadgetA(gtd.buttonKind, gad^, ng, TAG(taglist,
  429.       tagEnd));
  430.    gadget[KILLALLGADGET] := gad;
  431.  
  432.    (* Fenster öffnen: *)
  433.    str.Copy (wintitle, CAST(StrPtr, ll.GetCatalogStr(catalog, cxc.MSG_WINDOWTITLE, ADR(cxc.MSG_WINDOWTITLESTR)))^);
  434.    str.Concat (wintitle, " <");
  435.    str.Concat (wintitle, hotkey^);
  436.    str.ConcatChar (wintitle, ">");
  437.  
  438.    innerHeight := gadget[LISTGADGET]^.height;
  439.    dummy := bevelHeight + 3*(2+YSTEP+buttonHeight);
  440.    IF dummy > innerHeight THEN
  441.       innerHeight := dummy;
  442.    END;
  443.    INC (innerHeight, gadget[LISTGADGET]^.topEdge);
  444.  
  445.    window := il.OpenWindowTagList(NIL, TAG(taglist,
  446.       id.waLeft,        20,
  447.       id.waTop,         50,
  448.       id.waGimmeZeroZero, TRUE,
  449.       id.waGadgets,     glist,
  450.       id.waTitle,       ADR(wintitle),
  451.       id.waDragBar,     TRUE,
  452.       id.waCloseGadget, TRUE,
  453.       id.waDepthGadget, TRUE,
  454.       id.waActivate,    TRUE,
  455.       id.waInnerWidth,  bevelWidth + 10 + XSTEP + gadget[LISTGADGET]^.width,
  456.       id.waInnerHeight, innerHeight,
  457.       id.waPubScreen,   screen,
  458.       id.waNewLookMenus, TRUE,
  459.       id.waAutoAdjust,  TRUE,
  460.       tagEnd));
  461.  
  462.    il.UnlockPubScreen (NIL, screen);
  463.    IF window = NIL THEN
  464.       gtl.FreeGadgets (glist);
  465.       gtl.FreeVisualInfo (vi);
  466.       RETURN;
  467.    END;
  468.  
  469.    menuStrip := gtl.CreateMenusA(CAST(gtd.NewMenuPtr, mynewmenu), TAG(taglist, tagEnd));
  470.    IF menuStrip # NIL THEN
  471.       IF gtl.LayoutMenusA (menuStrip, vi, TAG(taglist,
  472.             gtd.gtmnNewLookMenus, TRUE,
  473.             tagEnd))
  474.       THEN
  475.          bool := il.SetMenuStrip (window, menuStrip);
  476.       ELSE
  477.          gtl.FreeMenus (menuStrip);
  478.          menuStrip := NIL;
  479.       END;
  480.    END;
  481.    el.FreeMem (mynewmenu, MENUCOUNT*SIZE(gtd.NewMenu));
  482.  
  483.    gtl.GTRefreshWindow (window, NIL);
  484.    
  485.    rp := window^.rPort;
  486.    topazfont := gl.OpenFont(font);
  487.    gl.SetFont (rp, topazfont);
  488.    infostr := ll.GetCatalogStr(catalog, cxc.MSG_INFORMATION, ADR(cxc.MSG_INFORMATIONSTR));
  489.    gl.Move (rp, BEVELLEFT + (bevelWidth DIV 2) -
  490.                 (gl.TextLength(rp, infostr, str.Length(infostr^)) DIV 2),
  491.                 gadget[LISTGADGET]^.topEdge - (CAST(INTEGER,
  492.                 font^.ySize) DIV 2) - 2);
  493.    gl.SetAPen (rp, 1);
  494.    gl.Text (rp, infostr, str.Length(infostr^));
  495.  
  496.    gtl.DrawBevelBoxA (rp, BEVELLEFT, gadget[LISTGADGET]^.topEdge, bevelWidth, bevelHeight,
  497.       TAG(taglist, gtd.gtVisualInfo,   vi,
  498.                    gtd.gtbbRecessed,   TRUE,
  499.                    tagEnd));
  500.  
  501.    (* Messageport dranbasteln: *)
  502.    el.Forbid();
  503.       window^.userPort := brokerport;
  504.       (*$ IF Debug *)
  505.          il.ModifyIDCMP (window, id.IDCMPFlagSet{id.gadgetUp,
  506.             id.closeWindow, id.menuPick, id.refreshWindow, id.rawKey,
  507.             id.vanillaKey});
  508.       (*$ ELSE *)
  509.          il.ModifyIDCMP(window,
  510.             id.IDCMPFlagSet{id.closeWindow,id.menuPick,id.vanillaKey,id.refreshWindow,id.rawKey} +
  511.             gtd.listviewIDCMP +
  512.             gtd.buttonIDCMP +
  513.             gtd.cycleIDCMP);
  514.       (*$ ENDIF *)
  515.       winreplyport := window^.windowPort;
  516.    el.Permit();
  517.  
  518. END ShowWindow;
  519. (* **)
  520.  
  521. PROCEDURE CloseWindowSafely (VAR win : id.WindowPtr);
  522. (** siehe Reference Manual: Libraries, Seite 254f *)
  523.  
  524.    PROCEDURE StripIntuiMessages (mp : ed.MsgPortPtr; win : id.WindowPtr);
  525.    VAR
  526.       msg   : id.IntuiMessagePtr;
  527.       succ  : ed.NodePtr;
  528.    BEGIN
  529.       msg := CAST(id.IntuiMessagePtr, mp^.msgList.head);
  530.       succ := msg^.execMessage.node.succ;
  531.       WHILE succ # NIL DO
  532.          IF msg^.idcmpWindow = win THEN
  533.             el.Remove (msg);
  534.             el.ReplyMsg (msg);
  535.          END;
  536.          msg := CAST(id.IntuiMessagePtr, succ);
  537.          succ := msg^.execMessage.node.succ;
  538.       END;
  539.    END StripIntuiMessages;
  540.  
  541. BEGIN
  542.    el.Forbid();
  543.    StripIntuiMessages (win^.userPort, win);
  544.    win^.userPort := NIL;
  545.    il.ModifyIDCMP (win, id.IDCMPFlagSet{});
  546.    el.Permit();
  547.    il.CloseWindow (win);
  548.    win := NIL;
  549. END CloseWindowSafely;
  550. (* **)
  551.  
  552. PROCEDURE RemoveWindow;
  553. (** "Fenster schließen; dafür belegten Speicher freigeben" *)
  554. BEGIN
  555.    IF window # NIL THEN
  556.       IF menuStrip # NIL THEN
  557.          il.ClearMenuStrip (window);
  558.          gtl.FreeMenus (menuStrip);
  559.          menuStrip := NIL;
  560.       END;
  561.       IF topazfont # NIL THEN
  562.          gl.CloseFont (topazfont);
  563.          topazfont := NIL;
  564.       END;
  565.       CloseWindowSafely (window);
  566.       winreplyport := NIL;
  567.       IF glist # NIL THEN
  568.          gtl.FreeGadgets (glist);
  569.          glist := NIL;
  570.       END;
  571.       IF vi # NIL THEN
  572.          gtl.FreeVisualInfo (vi);
  573.          vi := NIL;
  574.       END;
  575.       IF CycleLabels # NIL THEN
  576.          el.FreeMem (CycleLabels, 3*SIZE(ADDRESS));
  577.          CycleLabels := NIL;
  578.       END;
  579.       IF allCycleLabels # NIL THEN
  580.          el.FreeMem (allCycleLabels, 3*SIZE(ADDRESS));
  581.          allCycleLabels := NIL;
  582.       END;
  583.       IF brokerlist # NIL THEN
  584.          FreeCommoditiesList (brokerlist);
  585.          brokerlist := NIL;
  586.       END;
  587.    END;
  588.    (*$ IF Debug *)
  589.       t.WriteString ("Window removed\n");
  590.    (*$ ENDIF *)
  591. END RemoveWindow;
  592. (* **)
  593.  
  594. PROCEDURE ShowAbout;
  595. (** "Zeigt den über-Reqeuster an" *)
  596. VAR
  597.    easyreq  : id.EasyStruct;
  598.    idcmp    : id.IDCMPFlagSet;
  599.    num      : LONGINT;
  600. BEGIN
  601.    idcmp := id.IDCMPFlagSet{};
  602.    WITH easyreq DO
  603.       structSize  := SIZE(id.EasyStruct);
  604.       flags       := LONGSET{};
  605.       title       := ll.GetCatalogStr(catalog, cxc.MSG_REQUEST_TITLE, ADR(cxc.MSG_REQUEST_TITLESTR));
  606.       textFormat  := ll.GetCatalogStr(catalog, cxc.MSG_REQUEST_TEXT, ADR(cxc.MSG_REQUEST_TEXTSTR));
  607.       gadgetFormat:= ll.GetCatalogStr(catalog, cxc.MSG_REQUEST_GADGETS, ADR(cxc.MSG_REQUEST_GADGETSSTR));
  608.    END;
  609.    num := il.EasyRequestArgs(window, easyreq, idcmp, NIL);
  610. END ShowAbout;
  611. (* **)
  612.  
  613. PROCEDURE RemoveAllRequest () : BOOLEAN;
  614. (** "Requester: Wirklich alle Commodities entfernen?" *)
  615. VAR
  616.    easyreq  : id.EasyStruct;
  617.    idcmp    : id.IDCMPFlagSet;
  618.    num      : LONGINT;
  619. BEGIN
  620.    idcmp := id.IDCMPFlagSet{};
  621.    WITH easyreq DO
  622.       structSize  := SIZE(id.EasyStruct);
  623.       flags       := LONGSET{};
  624.       title       := ll.GetCatalogStr(catalog, cxc.MSG_REMOVEALL_GAD, ADR(cxc.MSG_REMOVEALL_GADSTR));
  625.       textFormat  := ll.GetCatalogStr(catalog, cxc.MSG_REQUEST_REMOVEALLTEXT, ADR(cxc.MSG_REQUEST_REMOVEALLTEXTSTR));
  626.       gadgetFormat:= ll.GetCatalogStr(catalog, cxc.MSG_REQUEST_REMOVEALL_GAD, ADR(cxc.MSG_REQUEST_REMOVEALL_GADSTR));
  627.    END;
  628.    num := il.EasyRequestArgs(window, easyreq, idcmp, NIL);
  629.    RETURN num = 1;
  630. END RemoveAllRequest;
  631. (* **)
  632.  
  633.  
  634.  
  635. PROCEDURE GetBrokerNode (item : CARDINAL) : cp.BrokerCopyPtr;
  636. (** "BrockerCopyPtr zum gewählten Item ermitteln" *)
  637. VAR
  638.    node  : ed.NodePtr;
  639. BEGIN
  640.    node := brokerlist^.head;
  641.    WHILE (node # NIL) & (item > 0) DO
  642.       node := node^.succ;
  643.       DEC (item);
  644.    END;
  645.    RETURN CAST(cp.BrokerCopyPtr, node);
  646. END GetBrokerNode;
  647. (* **)
  648.  
  649.  
  650. PROCEDURE ShowInformation (item : CARDINAL);
  651. (** "Name und Beschreibung des gewählten Brokers anzeigen" *)
  652. VAR
  653.    brokernode  : cp.BrokerCopyPtr;
  654.    rp          : gd.RastPortPtr;
  655.    baseline    : INTEGER;
  656.    ysize       : INTEGER;
  657. BEGIN
  658.    baseline := CAST(INTEGER, window^.rPort^.font^.baseline);
  659.    ysize := CAST(INTEGER, window^.rPort^.font^.ySize);
  660.  
  661.    brokernode := GetBrokerNode (item);
  662.    rp := window^.rPort;
  663.    gl.SetAPen (rp, 0);
  664.    gl.RectFill (rp, BEVELLEFT+2, gadget[LISTGADGET]^.topEdge+2,
  665.       BEVELLEFT+bevelWidth-4, gadget[LISTGADGET]^.topEdge+bevelHeight-3);
  666.    gl.SetAPen (rp, 1);
  667.    gl.Move (rp, BEVELLEFT+XSTEP, gadget[LISTGADGET]^.topEdge + baseline + YSTEP + 1);
  668.    gl.Text (rp, ADR(brokernode^.title), str.Length(brokernode^.title));
  669.    gl.Move (rp, BEVELLEFT+XSTEP, gadget[LISTGADGET]^.topEdge + baseline + 2*YSTEP + ysize + 2);
  670.    gl.Text (rp, ADR(brokernode^.descr), str.Length(brokernode^.descr));
  671. END ShowInformation;
  672. (* **)
  673.  
  674.  
  675. PROCEDURE UpdateGadgets (item : CARDINAL);
  676. (** "Gadgets neu zeichnen" *)
  677. VAR
  678.    brokernode  : cp.BrokerCopyPtr;
  679.    disable     : BOOLEAN;
  680.    taglist     : ARRAY [0..7] OF LONGINT;
  681. BEGIN
  682.    brokernode := GetBrokerNode(item);
  683.    
  684.    disable := NOT(cp.showhide IN brokernode^.flags);
  685.    gtl.GTSetGadgetAttrsA (gadget[SHOWGADGET], window, NIL, TAG(taglist, 
  686.       id.gaDisabled, disable, 
  687.       tagEnd));
  688.    gtl.GTSetGadgetAttrsA (gadget[HIDEGADGET], window, NIL, TAG(taglist, 
  689.       id.gaDisabled, disable,    
  690.       tagEnd));
  691.  
  692.    IF cp.active IN brokernode^.flags THEN
  693.       gtl.GTSetGadgetAttrsA (gadget[ENABLEGADGET], window, NIL, TAG(taglist, 
  694.          gtd.gtcyActive, 0, 
  695.          tagEnd));
  696.    ELSE
  697.       gtl.GTSetGadgetAttrsA (gadget[ENABLEGADGET], window, NIL, TAG(taglist, 
  698.          gtd.gtcyActive, 1, 
  699.          tagEnd));
  700.    END;
  701. END UpdateGadgets;
  702. (* **)
  703.  
  704.  
  705. PROCEDURE UpdateLV (item : CARDINAL);
  706. (** "List-Gadget aktualisieren" *)
  707. VAR
  708.    taglist  : ARRAY [0..3] OF LONGINT;
  709. BEGIN
  710.    gtl.GTSetGadgetAttrsA (gadget[LISTGADGET], window, NIL, TAG(taglist,
  711.       gtd.gtlvSelected, item,
  712.       tagEnd));
  713.    ShowInformation (item);
  714.    UpdateGadgets (item);
  715. END UpdateLV;
  716. (* **)
  717.  
  718. PROCEDURE MoreToUpdate (VAR item, maxitems : CARDINAL);
  719. BEGIN
  720.    maxitems := CountBrokers(brokerlist);
  721.    IF item > maxitems THEN
  722.       item := maxitems;
  723.    END;
  724.    UpdateLV (item);
  725. END MoreToUpdate;
  726.  
  727. PROCEDURE SendBrokerCommand (item : CARDINAL; command : LONGCARD);
  728. (** "Broker-Kommando verschicken" *)
  729. VAR
  730.    brokernode  : cp.BrokerCopyPtr;
  731.    li          : LONGINT;
  732. BEGIN
  733.    brokernode := GetBrokerNode(item);
  734.    IF brokernode # NIL THEN
  735.       IF cp.BrokerCommand(brokernode^.node.name, command) # cd.cmdeOk THEN
  736.          UpdateGadgets (item);
  737.       END;
  738.    END;
  739. END SendBrokerCommand;
  740. (* **)
  741.  
  742.  
  743. PROCEDURE EnableDisable (item : CARDINAL);
  744. (** "De-/Aktiviert das gewählte Commodity" *)
  745. VAR
  746.    brokernode : cp.BrokerCopyPtr;
  747. BEGIN
  748.    brokernode := GetBrokerNode(item);
  749.    IF cp.active IN brokernode^.flags THEN
  750.       SendBrokerCommand (item, cd.cxcmdDisable);
  751.    ELSE
  752.       SendBrokerCommand (item, cd.cxcmdEnable);
  753.    END;
  754. END EnableDisable;
  755. (* **)
  756.  
  757.  
  758. PROCEDURE TellAllBrokers (command : CARDINAL);
  759. (** "Broker-Kommando an alle Broker verschicken" *)
  760. VAR
  761.    node  : ed.NodePtr;
  762.    li    : LONGINT;
  763. BEGIN
  764.    node := brokerlist^.head;
  765.    WHILE node # NIL DO
  766.       li := cp.BrokerCommand(node^.name, command);
  767.       node := node^.succ;
  768.    END;
  769. END TellAllBrokers;
  770. (* **)
  771.  
  772. PROCEDURE DisableAll (VAR state : BOOLEAN);
  773. (** "Alle Commodities de-/aktiviren" *)
  774. VAR
  775.    taglist: ARRAY [0..3] OF LONGINT;
  776. BEGIN
  777.    IF state THEN
  778.       TellAllBrokers (cd.cxcmdDisable);
  779.       gtl.GTSetGadgetAttrsA (gadget[DISABLEALLGADGET], window, NIL, TAG(taglist,
  780.          gtd.gtcyActive, 1, tagEnd));
  781.    ELSE
  782.       TellAllBrokers (cd.cxcmdEnable);
  783.       gtl.GTSetGadgetAttrsA (gadget[DISABLEALLGADGET], window, NIL, TAG(taglist,
  784.          gtd.gtcyActive, 0, tagEnd));
  785.    END;
  786.    state := NOT(state);
  787. END DisableAll;
  788. (* **)
  789.  
  790. PROCEDURE ProcessMsg;
  791. (** "Hauptschleife"
  792.   * Hier werden alle eintreffenden Nachrichten ausgewertet.
  793.   *)
  794. VAR
  795.    done           : BOOLEAN;
  796.  
  797.    (* Message-Stuff: *)
  798.    waitsignals    : LONGSET;
  799.    sigrcvd        : LONGSET;
  800.    msg            : ed.MessagePtr;
  801.    
  802.    (* Broker-Message-Stuff: *)
  803.    msgid          : LONGINT;
  804.    msgtype        : LONGCARD;
  805.    
  806.    (* Intuition-Message-Kram: *)
  807.    gtmsg          : id.IntuiMessagePtr;
  808.    class          : id.IDCMPFlagSet;
  809.    gad            : id.GadgetPtr;
  810.    code           : CARDINAL;
  811.    qualifier      : iv.QualifierSet;
  812.    time           : MyTime;
  813.  
  814.    selectedbroker : CARDINAL;       (* gewählter Broker *)
  815.    maxbroker      : CARDINAL;       (* Anzahl der Broker im LV-Gadget *)
  816.    kcs            : StrPtr;
  817.  
  818.    disableall     : BOOLEAN;        (* TRUE, wenn "Alle deaktivierem", bei "Alle aktivieren" FALSE *)
  819.  
  820.    taglist        : ARRAY [0..7] OF LONGINT;
  821.    c              : CARDINAL;
  822.    ch             : CHAR;
  823.  
  824. BEGIN
  825.    kcs := CAST(StrPtr, ll.GetCatalogStr(catalog, cxc.MSG_KEYCODE, ADR(cxc.MSG_KEYCODESTR)));
  826.    disableall := TRUE;
  827.  
  828.    IF window # NIL THEN
  829.       maxbroker := CountBrokers(brokerlist);
  830.    END;
  831.    selectedbroker := 0;
  832.  
  833.    done := FALSE;
  834.    waitsignals := LONGSET{cxsigflag,dd.ctrlC};
  835.  
  836.    WHILE NOT(done) DO
  837.       (*$ IF Debug *)
  838.          t.WriteString ("waiting...\n");
  839.       (*$ ENDIF *)
  840.  
  841.       sigrcvd := el.Wait(waitsignals);
  842.  
  843.       (*$ IF Debug *)
  844.          t.WriteString ("rcvdSigs = ");
  845.          WriteCard (CAST(LONGCARD, sigrcvd),0); t.WriteLn;
  846.       (*$ ENDIF *)
  847.       LOOP
  848.          msg := el.GetMsg(brokerport);
  849.          IF msg = NIL THEN
  850.             EXIT; 
  851.          END;
  852.  
  853.          IF msg^.replyPort = winreplyport THEN
  854.             (* Empfangene Nachricht stammt von Intuition *)
  855.             (*$ IF Debug *)
  856.                t.WriteString (" Intuition Message rcvd\n");
  857.             (*$ ENDIF *)
  858.             gtmsg := gtl.GTFilterIMsg (CAST(id.IntuiMessagePtr, msg));
  859.             IF gtmsg # NIL THEN
  860.                class := gtmsg^.class;
  861.                gad := gtmsg^.iAddress;
  862.                code := gtmsg^.code;
  863.                qualifier := gtmsg^.qualifier;
  864.                msg := CAST(ed.MessagePtr, gtl.GTPostFilterIMsg(gtmsg));
  865.                el.ReplyMsg (msg);
  866.  
  867.                IF id.gadgetUp IN class THEN
  868.                   (*$ IF Debug *)
  869.                      t.WriteString ("  gadgetUp\n");
  870.                   (*$ ENDIF *)
  871.                   CASE gad^.gadgetID OF
  872.                      LISTGADGET:
  873.                         selectedbroker := code;
  874.                         ShowInformation (selectedbroker);
  875.                         UpdateGadgets (selectedbroker);
  876.                         IF il.DoubleClick (time.seconds, time.micros, gtmsg^.seconds, gtmsg^.micros) THEN
  877.                            SendBrokerCommand (selectedbroker, cd.cxcmdAppear);
  878.                         END;
  879.                         time.seconds := gtmsg^.seconds;
  880.                         time.micros := gtmsg^.micros;
  881.                    | SHOWGADGET:
  882.                         SendBrokerCommand (selectedbroker, cd.cxcmdAppear);
  883.                    | HIDEGADGET:
  884.                         SendBrokerCommand (selectedbroker, cd.cxcmdDisappear);
  885.                    | ENABLEGADGET:
  886.                         EnableDisable (selectedbroker);
  887.                    | DISABLEALLGADGET:
  888.                         DisableAll (disableall);
  889.                    | KILLGADGET:
  890.                         SendBrokerCommand (selectedbroker, cd.cxcmdKill);
  891.                    | KILLALLGADGET:
  892.                         IF NOT(requester) OR RemoveAllRequest() THEN
  893.                            TellAllBrokers (cd.cxcmdKill);
  894.                         END;
  895.                   ELSE
  896.                      (* unbekannte gadgetID *)
  897.                   END;
  898.  
  899.                ELSIF id.closeWindow IN class THEN
  900.                   (*$ IF Debug *)
  901.                      t.WriteString ("  closeWindow\n");
  902.                   (*$ ENDIF *)
  903.                   RemoveWindow;
  904.  
  905.                ELSIF id.menuPick IN class THEN
  906.                   (*$ IF Debug *)
  907.                      t.WriteString ("  menuPick\n");
  908.                   (*$ ENDIF *)
  909.                   CASE im.MenuNum(code) OF
  910.                      PROJEKT:
  911.                         CASE im.ItemNum(code) OF
  912.                            ABOUTMENU: ShowAbout;
  913.                          | HIDEMENU: RemoveWindow;
  914.                          | QUITMENU: done := TRUE;
  915.                          ELSE
  916.                         END;
  917.                    | EDIT:
  918.                         CASE im.ItemNum(code) OF
  919.                            DISABLEALLMENU: TellAllBrokers (cd.cxcmdDisable);
  920.                          | ENABLEALLMENU: TellAllBrokers (cd.cxcmdEnable);
  921.                          | KILLALLMENU: 
  922.                               IF NOT(requester) OR RemoveAllRequest() THEN
  923.                                  TellAllBrokers (cd.cxcmdKill);
  924.                               END;
  925.                          ELSE
  926.                         END;
  927.                    ELSE
  928.                   END;
  929.  
  930.                ELSIF id.vanillaKey IN class THEN
  931.                   ch := CHAR(code);
  932.                   (*$ IF Debug *)
  933.                      t.WriteString ("  vanillaKey = ");
  934.                      t.Write (ch); t.WriteLn;
  935.                   (*$ ENDIF *)
  936.                   IF (ch = kcs^[0]) OR (ch = kcs^[1]) THEN
  937.                      SendBrokerCommand (selectedbroker, cd.cxcmdAppear);
  938.                   ELSIF (ch = kcs^[2]) OR (ch = kcs^[3]) THEN
  939.                         SendBrokerCommand (selectedbroker, cd.cxcmdDisappear);
  940.                   ELSIF (ch = kcs^[4]) OR (ch = kcs^[5]) THEN
  941.                         SendBrokerCommand (selectedbroker, cd.cxcmdKill);
  942.                   ELSIF (ch = kcs^[6]) OR (ch = kcs^[7]) THEN
  943.                         DisableAll (disableall);
  944.                   ELSIF ch = kcs^[8] THEN
  945.                      IF selectedbroker < maxbroker THEN
  946.                         INC (selectedbroker);
  947.                         UpdateLV (selectedbroker);
  948.                      END;
  949.                   ELSIF ch = kcs^[9] THEN
  950.                      IF selectedbroker > 0 THEN
  951.                         DEC (selectedbroker);
  952.                         UpdateLV (selectedbroker);
  953.                      END;
  954.                   ELSIF (ch = kcs^[10]) OR (ch = kcs^[11]) THEN
  955.                      EnableDisable (selectedbroker);
  956.                   (* Besondere Zeichen: *)
  957.                   ELSIF ch = ASCII.cr THEN
  958.                      SendBrokerCommand (selectedbroker, cd.cxcmdAppear);
  959.                   ELSIF ch = ASCII.esc THEN
  960.                      RemoveWindow;
  961.                   END;
  962.  
  963.                ELSIF id.rawKey IN class THEN
  964.                   (*$ IF Debug *)
  965.                      t.WriteString ("  rawKey\n");
  966.                   (*$ ENDIF *)
  967.                   (* Cursorbewegungen: *)
  968.                   IF code = id.cursorUp THEN
  969.                      IF (iv.lShift IN qualifier) OR
  970.                         (iv.rShift IN qualifier) THEN
  971.                         selectedbroker := 0;
  972.                      ELSE
  973.                         IF selectedbroker = 0 THEN
  974.                            selectedbroker := maxbroker;
  975.                         ELSE
  976.                            DEC (selectedbroker);
  977.                         END;
  978.                      END;
  979.                      UpdateLV (selectedbroker);
  980.                   ELSIF code = id.cursorDown THEN
  981.                      IF (iv.lShift IN qualifier) OR (iv.rShift IN qualifier) THEN
  982.                         selectedbroker := maxbroker;
  983.                      ELSE
  984.                         selectedbroker := (selectedbroker+1) MOD (maxbroker+1);
  985.                      END;
  986.                      UpdateLV (selectedbroker);
  987.                   END;
  988.  
  989.                ELSIF id.refreshWindow IN class THEN
  990.                   (*$ IF Debug *)
  991.                      t.WriteString ("  refreshWindow\n");
  992.                   (*$ ENDIF *)
  993.                   gtl.GTBeginRefresh (window);
  994.                   gtl.GTEndRefresh (window, TRUE);
  995.  
  996.                ELSE
  997.                   (*$ IF Debug *)
  998.                      t.WriteString ("  other Intui Msg\n");
  999.                   (*$ ENDIF *)
  1000.                   (* nicht erwartete/interessante IntuiMessage *)
  1001.                END;
  1002.             ELSE
  1003.                (* Ist zwar eine Intui-Nachricht; diese wurde aber
  1004.                 * von den GadTools-Gadgets geschluckt -> nur
  1005.                 * beantworten: *)
  1006.                el.ReplyMsg (msg);
  1007.             END;
  1008.  
  1009.          ELSE
  1010.             (* Broker-Message empfangen. *)
  1011.             (*$ IF Debug *)
  1012.                t.WriteString (" Broker Msg\n");
  1013.             (*$ ENDIF *)
  1014.             msgid := cl.CxMsgID(CAST(cd.CxMsgPtr, msg));
  1015.             msgtype := cl.CxMsgType(CAST(cd.CxMsgPtr, msg));
  1016.             el.ReplyMsg (msg);
  1017.  
  1018.             CASE msgtype OF
  1019.                cd.cxmIevent:
  1020.                   (*$ IF Debug *)
  1021.                      t.WriteString ("  cxmIevent\n");
  1022.                   (*$ ENDIF *)
  1023.                   CASE msgid OF
  1024.                      IVHOTKEY:
  1025.                         (*$ IF Debug *)
  1026.                            t.WriteString ("     IVHOTKEY\n");
  1027.                         (*$ ENDIF *)
  1028.                         ShowWindow;
  1029.                         MoreToUpdate (selectedbroker, maxbroker);
  1030.                   ELSE
  1031.                      (*$ IF Debug *)
  1032.                         t.WriteString ("    Unknown Ievent\n");
  1033.                      (*$ ENDIF *)
  1034.                   END;
  1035.              | cd.cxmCommand:
  1036.                   (*$ IF Debug *)
  1037.                      t.WriteString ("  cxmCommand = ");
  1038.                   (*$ ENDIF *)
  1039.                   CASE msgid OF
  1040.                      cd.cxcmdDisable:
  1041.                         (*$ IF Debug *)
  1042.                            t.WriteString ("Disable\n");
  1043.                         (*$ ENDIF *)
  1044.                         bool := cl.ActivateCxObj(broker, FALSE);
  1045.                    | cd.cxcmdEnable:
  1046.                         (*$ IF Debug *)
  1047.                            t.WriteString ("Enable\n");
  1048.                         (*$ ENDIF *)
  1049.                         bool := cl.ActivateCxObj(broker, TRUE);
  1050.                    | cd.cxcmdKill:
  1051.                         (*$ IF Debug *)
  1052.                            t.WriteString ("Kill\n");
  1053.                         (*$ ENDIF *)
  1054.                         done := TRUE;
  1055.                    | cd.cxcmdAppear:
  1056.                         (*$ IF Debug *)
  1057.                            t.WriteString ("Appear\n");
  1058.                         (*$ ENDIF *)
  1059.                         ShowWindow;
  1060.                         MoreToUpdate (selectedbroker, maxbroker);
  1061.                    | cd.cxcmdDisappear:
  1062.                         (*$ IF Debug *)
  1063.                            t.WriteString ("Disappear\n");
  1064.                         (*$ ENDIF *)
  1065.                         RemoveWindow;
  1066.                    | cd.cxcmdListChg:
  1067.                         (*$ IF Debug *)
  1068.                            t.WriteString ("LstChg\n");
  1069.                         (*$ ENDIF *)
  1070.                         IF window # NIL THEN
  1071.                            (*$ IF Debug *)
  1072.                               t.WriteString ("    window # NIL\n");
  1073.                            (*$ ENDIF *)
  1074.                            UpdateCommoditiesList (brokerlist);
  1075.                            maxbroker := CountBrokers(brokerlist);
  1076.                            IF selectedbroker > maxbroker THEN
  1077.                               selectedbroker := maxbroker;
  1078.                               gtl.GTSetGadgetAttrsA(gadget[LISTGADGET],
  1079.                                  window, NIL, TAG(taglist,
  1080.                                  gtd.gtlvSelected, selectedbroker,
  1081.                                  tagEnd));
  1082.                            END;
  1083.                            ShowInformation (selectedbroker);
  1084.                            UpdateGadgets (selectedbroker);
  1085.                         END;
  1086.                    | cd.cxcmdUnique:
  1087.                         (*$ IF Debug *)
  1088.                            t.WriteString ("Unique\n");
  1089.                         (*$ ENDIF *)
  1090.                         ShowWindow;
  1091.                         MoreToUpdate (selectedbroker, maxbroker);
  1092.                   ELSE
  1093.                      (*$ IF Debug *)
  1094.                         t.WriteString ("Unknown\n");
  1095.                      (*$ ENDIF *)
  1096.                   END;
  1097.             ELSE
  1098.                (*$ IF Debug *)
  1099.                   t.WriteString ("Other Broker.\n");
  1100.                (*$ ENDIF *)
  1101.             END;
  1102.          END;
  1103.       END;
  1104.  
  1105.       IF dd.ctrlC IN sigrcvd THEN
  1106.          (*$ IF Debug *)
  1107.             t.WriteString (" CTRL-C\n");
  1108.          (*$ ENDIF *)
  1109.          done := TRUE;
  1110.       END;
  1111.    END;
  1112. END ProcessMsg;
  1113. (* **)
  1114.  
  1115. VAR
  1116.    taglist: ARRAY [0..3] OF LONGINT;
  1117. BEGIN (* main *)
  1118.    catalog := ll.OpenCatalogA (NIL, ADR("CX.catalog"), TAG(taglist,
  1119.       ld.ocBuiltInLanguage, ADR("english"),
  1120.       tagEnd));
  1121.  
  1122.    brokerport := el.CreateMsgPort();
  1123.    IF brokerport # NIL THEN
  1124.       WITH nb DO
  1125.          version := cd.nbVersion;
  1126.          name     := ADR("Exchange");
  1127.                      (*   ^^^^^^^^                                *)
  1128.                      (* Wichtig! Nur ein Broker mit diesem Namen  *)
  1129.                      (* kann die wichtigen cxcmdListChg-Kommandos *)
  1130.                      (* empfangen.                                *)
  1131.          title    := ADR("CX V1.3 © 1994 Fin Schuppenhauer");
  1132.          descr    := ll.GetCatalogStr(catalog, cxc.MSG_BROKERDESCR, ADR(cxc.MSG_BROKERDESCRSTR));
  1133.          port     := brokerport;
  1134.          unique   := cd.UniqueFlagSet{cd.unique, cd.notify};
  1135.          flags    := cd.NewBrokerFlagSet{cd.showHide};
  1136.          pri      := cs.ArgInt(ADR("CX_PRIORITY"), 0);
  1137.       END;
  1138.       broker := cl.CxBroker(nb, error);
  1139.       IF error = cd.cberrOk THEN
  1140.          defhotkey := "control alt help";
  1141.          hotkey := cs.ArgString(ADR("CX_POPKEY"), ADR(defhotkey));
  1142.          hotkeyfilter := cs.HotKey(hotkey, brokerport, IVHOTKEY);
  1143.          IF hotkeyfilter # NIL THEN
  1144.             cl.AttachCxObj (broker, hotkeyfilter);
  1145.          END;
  1146.  
  1147.          cxsigflag := brokerport^.sigBit;
  1148.          bool := cl.ActivateCxObj (broker, TRUE);
  1149.  
  1150.          (* Sollen Abfrage-Requester angezeigt werden? *)
  1151.          dummystr := cs.ArgString(ADR("REQUESTER"), ADR("NO"));
  1152.          requester := (str.Compare(dummystr^, "YES") = 0);
  1153.  
  1154.          dummystr := cs.ArgString(ADR("CX_POPUP"), ADR("YES"));
  1155.          IF str.Compare(dummystr^, "YES") = 0 THEN
  1156.             ShowWindow;
  1157.          END;
  1158.          ProcessMsg;
  1159.          RemoveWindow;
  1160.  
  1161.          cl.DeleteCxObjAll(broker);
  1162.  
  1163.          (* Ausstehende Nachrichten beantworten: *)
  1164.          LOOP
  1165.             msg := el.GetMsg(brokerport);
  1166.             IF msg = NIL THEN EXIT; END;
  1167.             el.ReplyMsg(msg);
  1168.          END;
  1169.       END;
  1170.       es.DeletePort (brokerport);
  1171.    END;
  1172.  
  1173.    ll.CloseCatalog (catalog);
  1174. END CX.
  1175.